package model;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;
import java.util.Vector;

import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;

public class Cliente
    implements
        DiscoveryListener
{

    private Object lock;;
    private Vector<RemoteDevice> dDescobertos;
    private String connectionURL;
    private LocalDevice localDevice;
    private DiscoveryAgent dAgente;
    private UUID[] uuidset;
    private BufferedReader bReader;
    

    public Cliente( String uuidgen )
    {
        lock = new Object();
        dDescobertos = new Vector<RemoteDevice>();
        uuidset = new UUID[ 1 ];
        uuidset[ 0 ] = new UUID( uuidgen, true );
        try {
            localDevice = LocalDevice.getLocalDevice();
        } catch( BluetoothStateException e ) {
            
        }
        bReader = new BufferedReader( new InputStreamReader( System.in ) );  
    }

    private void encontrarElistarDispositivos()
    {

        dAgente = localDevice.getDiscoveryAgent();
        System.out.println( "Inquiry..." );

        try {
            dAgente.startInquiry( DiscoveryAgent.GIAC, this );
        } catch( BluetoothStateException e ) {
            System.out.println( "Cliente: Inquiry mal sucedida." );
            e.printStackTrace();
        }

        try {
            synchronized( lock ) {
                lock.wait();
            }
        } catch( InterruptedException e ) {
            e.printStackTrace();
        }
        System.out.println( "Cliente: Inquiry completo." );

        imprimirEncontrados( dDescobertos );

    }

    private void imprimirEncontrados(
        Vector<RemoteDevice> v )
    {
        int nDispositivos = v.size();
        if( nDispositivos <= 0 )
            System.out.println( "Cliente: Não encontrei" );
        else {
            RemoteDevice rd;
            for( int i = 0; i < nDispositivos; i++ ) {
                rd = v.elementAt( i );
                System.out.println( ( i + 1 ) + " > " + rd.getBluetoothAddress() );
            }
        }
    }

    private void buscarServicosConexao(
        Vector<RemoteDevice> vetor )
    {
        int nDispositivos = vetor.size();
        int indiceDoDispositivoNaTela = - 1;
        
        RemoteDevice rd = null;
        if( nDispositivos <= 0 )
            System.out.println( "Cliente: Não encontrei" );
        else {
            System.out.println( "Cliente: Escolhe dispositivo para pedir a conexão" );
            try {
                indiceDoDispositivoNaTela = Integer.parseInt( bReader.readLine().trim() );
            } catch( NumberFormatException e1 ) {
                System.out.println( "Cliente: Numero fora de formato" + e1 );
            } catch( IOException e1 ) {
                System.out.println( "Cliente: Leitura incorreta" );
            }

            rd = vetor.elementAt( indiceDoDispositivoNaTela - 1 );

            try {
                System.out.println( "Cliente: Buscando serviços..." );
                dAgente.searchServices( null, uuidset, rd, this );
            } catch( BluetoothStateException e ) {
                System.out.println( "Cliente: Não foi possivel buscar serviços." );
                e.printStackTrace();
            }
            try {
                synchronized( lock ) {
                    lock.wait();
                }
            } catch( InterruptedException e ) {
                e.printStackTrace();
            }
        }

        if( connectionURL == null ) {
            System.out.println( "Cliente: Dispositivo não suporta SPP" );
            System.exit( 0 );
        }

        try {
            StreamConnection sc = (StreamConnection) Connector.open( connectionURL );
        } catch( IOException e ) {
            System.out.println( "Cliente: problema ao conectar com o servidor." );
            e.printStackTrace();
        }
    }

    @Override
    public void deviceDiscovered(
        RemoteDevice rd,
        DeviceClass dc )
    {
        if( ! dDescobertos.contains( rd ) )
            dDescobertos.add( rd );
    }

    @Override
    public void inquiryCompleted(
        int arg0 )
    {
        synchronized( lock ) {
            lock.notify();
        }
    }

    @Override
    public void serviceSearchCompleted(
        int arg0,
        int arg1 )
    {
        synchronized( lock ) {
            lock.notify();
        }
    }

    @Override
    public void servicesDiscovered(
        int arg0,
        ServiceRecord[] srec )
    {
        if( srec != null && srec.length > 0 )
            connectionURL = srec[ 0 ].getConnectionURL( 0, false );
        synchronized( lock ) {
            lock.notify();
        }
    }
}